home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / tie / src / screen.c < prev    next >
C/C++ Source or Header  |  1991-10-18  |  8KB  |  355 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <egb.h>
  7. #include <mos.h>
  8. #include <msdos.cf>
  9. #include "tie.h"
  10.  
  11. /*
  12. typedef struct
  13. {
  14.     int     b, r, g ;
  15. } PALET ;
  16. */
  17.  
  18. void    DSP_writePage( char *work, int page )
  19. {
  20.     EGB_writePage( work, page ) ;
  21.     if( page == 0 )
  22.         writepage = PAGE0 ;
  23.     else
  24.         writepage = PAGE1 ;
  25. }
  26.  
  27. void    cls( int page, int color ) /*  画面クリア  */
  28. {
  29.     DSP_writePage( egbwork, page ) ;
  30.     EGB_color( egbwork, 1, color ) ;
  31.     EGB_clearScreen( egbwork ) ;
  32. }
  33.  
  34.  
  35. void    set_palette( int color, int b, int r, int g )
  36. {
  37.     struct
  38.     {
  39.         int         num ;
  40.         int         col ;
  41.         u_char      b, r, g, dum ;
  42.     } para ;
  43.  
  44.     para.num = 1 ;
  45.     para.col = color ;
  46.     para.r = r ;
  47.     para.g = g ;
  48.     para.b = b ;
  49.     para.dum = 0 ;
  50.     EGB_palette( egbwork, 0, (char *)¶ ) ;
  51. }
  52.  
  53. void    dsp_ptn( int x, int y, char *ptn, int color )
  54. {
  55.     struct
  56.     {
  57.         char        *ptn ;
  58.         short int   sel ;
  59.         short int   x1, y1 ;
  60.         short int   x2, y2 ;
  61.     } para ;
  62.  
  63.     para.ptn = ptn ;
  64.     para.sel = getds() ;
  65.     para.x1 = x ;
  66.     para.y1 = y ;
  67.     para.x2 = x + 31 ;
  68.     para.y2 = y + 31 ;
  69.     EGB_color( egbwork, 0, color ) ;
  70.     EGB_putBlockColor( egbwork, 0, (char *)¶ ) ;
  71. }
  72.  
  73. void    DSP_ptn( int x, int y, int xsiz, int ysiz, char *ptn, int color )
  74. {
  75.     struct
  76.     {
  77.         char        *ptn ;
  78.         short int   sel ;
  79.         short int   x1, y1 ;
  80.         short int   x2, y2 ;
  81.     } para ;
  82.  
  83.     para.ptn = ptn ;
  84.     para.sel = getds() ;
  85.     para.x1 = x ;
  86.     para.y1 = y ;
  87.     para.x2 = x + xsiz ;
  88.     para.y2 = y + ysiz ;
  89.     EGB_color( egbwork, 0, color ) ;
  90.     EGB_putBlockColor( egbwork, 0, (char *)¶ ) ;
  91. }
  92.  
  93. void    dsp_box( int x1, int y1, int x2, int y2,
  94.                     int forcol, int bakcol, int boxcol )
  95. {
  96.     struct {
  97.         short int   x1, y1, x2, y2 ;
  98.     } line ;
  99.     struct {
  100.         short int   count ;
  101.         short int   x1, y1, x2, y2, x3, y3 ;
  102.     } connect ;
  103.  
  104.     EGB_linePattern( egbwork, 1, 0xFFFFFFFF ) ;
  105.  
  106.     line.x1 = x1 ;
  107.     line.y1 = y1 ;
  108.     line.x2 = x2 ;
  109.     line.y2 = y2 ;
  110.     EGB_paintMode( egbwork, 0x022 ) ;
  111.     EGB_color( egbwork, 0, forcol ) ;
  112.     EGB_color( egbwork, 2, boxcol ) ;
  113.     EGB_rectangle( egbwork, (char *)&line ) ;
  114.  
  115.     if( forcol == bakcol )
  116.         return ;
  117.  
  118.     connect.count = 3 ;
  119.     connect.x1 = x1 ;
  120.     connect.y1 = y2 ;
  121.     connect.x2 = x2 ;
  122.     connect.y2 = y2 ;
  123.     connect.x3 = x2 ;
  124.     connect.y3 = y1 ;
  125.     EGB_color( egbwork, 0, bakcol ) ;
  126.     EGB_connect( egbwork, (char *)&connect ) ;
  127. }
  128.  
  129. void    DSP_clip_on( register EVENT *ep )
  130. {
  131.     struct
  132.     {
  133.         char        *ptn ;
  134.         short int   sel ;
  135.         short int   x1, y1 ;
  136.         short int   x2, y2 ;
  137.     } para ;
  138.     struct
  139.     {
  140.         short int   count ;
  141.         short int   x1,y1, x2,y2, x3,y3 ;
  142.     } connect ;
  143.     int     n ;
  144.     char    *ptn ;
  145.  
  146.     n = (ep->x2 - ep->x1 + 7) * (ep->y2 - ep->y1 + 1) / 8 * 4 ;
  147.     if( ( ptn = (char *)malloc( n ) ) == NULL )
  148.         return ;
  149.  
  150.     MOS_disp(FALSE);
  151.  
  152.     para.ptn = ptn;
  153.     para.sel = getds();
  154.     para.x1 = ep->x1;
  155.     para.y1 = ep->y1;
  156.     para.x2 = ep->x2-1;
  157.     para.y2 = ep->y2-1;
  158.     EGB_getBlock(egbwork,(char *)¶);
  159.  
  160.     para.ptn = ptn;
  161.     para.sel = getds();
  162.     para.x1 = ep->x1+1;
  163.     para.y1 = ep->y1+1;
  164.     para.x2 = ep->x2;
  165.     para.y2 = ep->y2;
  166.     EGB_putBlock(egbwork,0,(char *)¶);
  167.  
  168.     connect.count = 3;
  169.     connect.x1 = ep->x1;
  170.     connect.y1 = ep->y2;
  171.     connect.x2 = ep->x1;
  172.     connect.y2 = ep->y1;
  173.     connect.x3 = ep->x2;
  174.     connect.y3 = ep->y1;
  175.     EGB_linePattern( egbwork, 1, 0xFFFFFFFF ) ;
  176.     EGB_color(egbwork,0,0);
  177.     EGB_connect(egbwork,(char *)&connect);
  178.  
  179.     MOS_disp(TRUE);
  180.  
  181.     free(ptn);
  182. }
  183. void    DSP_clip_off( register EVENT *ep )
  184. {
  185.     struct {
  186.         char        *ptn;
  187.         short int   sel;
  188.         short int   x1,y1;
  189.         short int   x2,y2;
  190.     } para;
  191.     struct {
  192.         short int       count;
  193.         short int       x1,y1,x2,y2,x3,y3;
  194.     } connect;
  195.     int     n;
  196.     char    *ptn;
  197.  
  198.     n = (ep->x2 - ep->x1 + 7) * (ep->y2 - ep->y1 + 1) / 8 * 4 ;
  199.     if( ( ptn = (char *)malloc( n ) ) == NULL )
  200.         return ;
  201.  
  202.     MOS_disp(FALSE);
  203.  
  204.     para.ptn = ptn;
  205.     para.sel = getds();
  206.     para.x1 = ep->x1+1;
  207.     para.y1 = ep->y1+1;
  208.     para.x2 = ep->x2;
  209.     para.y2 = ep->y2;
  210.     EGB_getBlock(egbwork,(char *)¶);
  211.  
  212.     para.ptn = ptn;
  213.     para.sel = getds();
  214.     para.x1 = ep->x1;
  215.     para.y1 = ep->y1;
  216.     para.x2 = ep->x2-1;
  217.     para.y2 = ep->y2-1;
  218.     EGB_putBlock(egbwork,0,(char *)¶);
  219.  
  220.     connect.count = 3;
  221.     connect.x1 = ep->x1;
  222.     connect.y1 = ep->y2;
  223.     connect.x2 = ep->x2;
  224.     connect.y2 = ep->y2;
  225.     connect.x3 = ep->x2;
  226.     connect.y3 = ep->y1;
  227.     EGB_linePattern( egbwork, 1, 0xFFFFFFFF ) ;
  228.     EGB_color(egbwork,0,8);
  229.     EGB_connect(egbwork,(char *)&connect);
  230.  
  231.     MOS_disp(TRUE);
  232.  
  233.     free(ptn);
  234. }
  235.  
  236. void    chg_palette( int page, int num )
  237. {
  238.     typedef struct
  239.     {
  240.         long        num ;
  241.         struct
  242.         {
  243.             int     col ;
  244.             u_char  b, r, g, dum ;
  245.         }           rgb[16] ;
  246.     } TABLE ;
  247.     
  248.     TABLE   palet[3] = {
  249.     { 16, {
  250.       { 0, 0,  0,  0},{ 1,  0,  0,  0},{ 2,  0, 96,  0},{ 3, 96, 96,  0},
  251.       { 4, 0,  0, 96},{ 5, 96,  0, 96},{ 6,  0,144,144},{ 7,128,128,128},
  252.       { 8,64, 64, 64},{ 9,192,  0,  0},{10,  0,192,  0},{11,192,192,  0},
  253.       {12, 0,  0,192},{13,192,  0,192},{14,230,230,230},{15,192,192,192}, }, },
  254.  
  255.     { 16, {
  256.       { 0, 0,  0,  0},{ 1,  0, 0,  0},{ 2,  0, 32,  0}, { 3, 32, 32,  0},
  257.       { 4, 0,  0, 32},{ 5, 32, 0, 32},{ 6,  0, 32, 32}, { 7, 32, 32, 32},
  258.       { 8,16, 16, 16},{ 9, 64, 0,  0},{10,  0, 64,  0}, {11, 64, 64,  0},
  259.       {12, 0,  0, 64},{13, 64, 0, 64},{14, 96, 96, 96}, {15, 64, 64, 64}, }, },
  260.  
  261.     { 16, {
  262.       { 0, 0,  0,  0},{ 1,  0,  0,  0},{ 2,  0,128,  0},{ 3,128,128,  0},
  263.       { 4, 0,  0,128},{ 5,128,  0,128},{ 6,  0,128,128},{ 7,128,128,128},
  264.       { 8,64, 64, 64},{ 9,200,  0,  0},{10,  0,200,  0},{11,200,200,  0},
  265.       {12, 0,  0,200},{13,200,  0,200},{14,255,255,255},{15,230,230,230}, }, },
  266.     } ;
  267.  
  268.     DSP_writePage( egbwork, page ) ;
  269.     EGB_palette( egbwork, 0, (char *)&palet[num] ) ;
  270. }
  271.  
  272.  
  273. /*  x1,y1 - x2,y1 - x2,y2 - x1,y2 の四角を書く  */
  274.  
  275. void    box( int x1, int y1, int x2, int y2, int color, int pattern, int mode )
  276. {
  277.     struct {
  278.         short int   count ;
  279.         short int   x1,y1, x2,y2, x3,y3, x4,y4, x5,y5 ;
  280.     } connect ;
  281.  
  282.     EGB_color( egbwork, 0, color ) ;
  283.     EGB_linePattern( egbwork, 0, pattern ) ;
  284.     EGB_writeMode( egbwork, mode ) ;
  285.  
  286.     connect.count = 5 ;
  287.     connect.x1 = x1 ;
  288.     connect.y1 = y1 ;
  289.     connect.x2 = x2 ;
  290.     connect.y2 = y1 ;
  291.     connect.x3 = x2 ;
  292.     connect.y3 = y2 ;
  293.     connect.x4 = x1 ;
  294.     connect.y4 = y2 ;
  295.     connect.x5 = x1 ;
  296.     connect.y5 = y1 ;
  297.     EGB_connect( egbwork, (char *)&connect ) ;
  298.  
  299.     EGB_writeMode( egbwork, MODE_PSET ) ;
  300. }
  301.  
  302. void    box2( int x1, int y1, int x2, int y2, int color1, int color2 )
  303. {
  304.     struct {
  305.         short int   count ;
  306.         short int   x1,y1, x2,y2, x3,y3 ;
  307.     } connect ;
  308.  
  309.     EGB_linePattern( egbwork, 0, 0xFFFFFFFF ) ;
  310.  
  311.     connect.count = 3 ;
  312.     connect.x1 = x2 ;
  313.     connect.y1 = y1 ;
  314.     connect.x2 = x1 ;
  315.     connect.y2 = y1 ;
  316.     connect.x3 = x1 ;
  317.     connect.y3 = y2 ;
  318.     EGB_color( egbwork, 0, color1 ) ;
  319.     EGB_connect( egbwork, (char *)&connect ) ;
  320.  
  321.     connect.count = 3 ;
  322.     connect.x1 = x2 ;
  323.     connect.y1 = y1 ;
  324.     connect.x2 = x2 ;
  325.     connect.y2 = y2 ;
  326.     connect.x3 = x1 ;
  327.     connect.y3 = y2 ;
  328.     EGB_color( egbwork, 0, color2 ) ;
  329.     EGB_connect( egbwork, (char *)&connect ) ;
  330. }
  331.  
  332. void    getputBlock( int x1, int y1, int x2, int y2, char *ptn, int flag )
  333. {
  334.     static  struct {
  335.         char        *ptn ;
  336.         short int   sel ;
  337.         short int   x1, y1 ;
  338.         short int   x2, y2 ;
  339.     } para ;
  340.  
  341.     para.x1 = x1 ;
  342.     para.x2 = x2 ;
  343.     para.y1 = y1 ;
  344.     para.y2 = y2 ;
  345.  
  346.     para.ptn = ptn ;
  347.     para.sel = getds() ;
  348.  
  349.     if( flag == TRUE )
  350.         EGB_getBlock( egbwork, (char *)¶ ) ;
  351.     else
  352.         EGB_putBlock( egbwork, 0, (char *)¶ ) ;
  353. }
  354.  
  355.